import request from "./request";
import message from "./message";
import  bignumber from 'bignumber.js'
import jQuery from "jquery";
import { getApproveFormData } from "./getInitiateFormData";//获取审批表单数据

//返回链接上的参数
var qs = require("qs");
export function getQuery(type = "object") {
  if (window.location.search) {
    const queryStr = window.location.search;
    if (type === "string") {
      return queryStr;
    }
    return qs.parse(queryStr, { ignoreQueryPrefix: true });
  }
  return {};
}

//新开页面，兼容浏览器阻止window.open，Safari 360等浏览器调用window.open会被浏览器阻止掉，需要设置允许打开才可以点击
export function openWin(url) {
  try {
    var el1 = document.createElement("a");
    el1.setAttribute("target", "_blank");
    el1.setAttribute("id", "openWin");
    el1.setAttribute("rel", "opener");
    el1.setAttribute("href", url);
    document.body.appendChild(el1);
    document.getElementById("openWin").click(); //点击事件
    document.body.removeChild(el1);
  } catch (e) {
    window.open(url);
  }
}

/**
 * @private
 * @param sUrl
 * @param oParameters
 * @returns {{url: (string|*), postData: Array}}
 * @private
 */
function _appendParameters(sUrl, oParameters) {
  // 把参数提出成为数组并排序
  var arrParameter = [];
  if (oParameters) {
    for (var i in oParameters) {
      var val = oParameters[i];
      if (typeof val != "function") {
        if (val === undefined || val === null || (typeof val == "number" && isNaN(val))) {
          val = "";
        }
        arrParameter.push({
          key: i,
          originalValue: val,
          value: encodeURIComponent(val.toString()),
        });
      }
    }

    arrParameter.sort(function (a, b) {
      return a.value.length - b.value.length;
    });
  }

  sUrl = sUrl || "";
  var maxUrlLength = 2048; // 最大 URL 长度,取 IE6 的值（最小值）
  var postData = []; // 需要 POST 的数据
  var hash = "";
  var idxHash = sUrl.indexOf("#");
  if (idxHash > -1) {
    hash = sUrl.substr(idxHash);
    sUrl = sUrl.substr(0, idxHash);
  }

  var splitChar = "?";
  var queryIndex = sUrl.indexOf("?");
  var query = {};
  if (queryIndex > -1) {
    // 重新整理原来的参数,去除重复键
    var arrQueryString = sUrl.substr(queryIndex + 1).split("&");
    sUrl = sUrl.substr(0, queryIndex);
    for (var i = 0; i < arrQueryString.length; i++) {
      var exp = arrQueryString[i];
      var eqIndex = exp.indexOf("=");
      if (eqIndex > -1) {
        var key = exp.substr(0, eqIndex);
        var value = exp.substr(eqIndex + 1);
        query[key] = value;
      }
    }

    // 更新原始的查询参数,去除重复键
    for (var i = 0; i < arrParameter.length; ++i) {
      var param = arrParameter[i];
      if (param.key in query) {
        query[param.key] = param.value;
        arrParameter.splice(i--, 1);
      }
    }

    // 拼接原始的 URL,并判断是否已超长
    for (var p in query) {
      var sNewParameter = splitChar + p + "=" + query[p];
      if (sUrl.length + sNewParameter.length + hash.length >= maxUrlLength) {
        // 超过了最大长度,超过的数据使用 POST 发送
        postData.push({
          key: p,
          value: query[p],
        });
      } else {
        sUrl += sNewParameter;
        if (splitChar == "?") {
          splitChar = "&";
        }
      }
    }
  }

  // 合并查询参数到 URL
  for (var i = 0; i < arrParameter.length; ++i) {
    var param = arrParameter[i];
    var sNewParameter = splitChar + param.key + "=" + param.value;
    if (sUrl.length + sNewParameter.length + hash.length >= maxUrlLength) {
      // 超过了最大长度,超过的数据使用 POST 发送
      postData = postData.concat(arrParameter.slice(i, arrParameter.length));
      break;
    } else {
      sUrl += sNewParameter;
      if (splitChar == "?") {
        splitChar = "&";
      }
    }
  }

  sUrl += hash;
  return {
    url: sUrl,
    postData: postData,
  };
}
/**
 * 创建Url
 * @param  {String} sUrl        url字符串
 * @param  {Object} oParameters {Object} 附加参数
 * @return {String}             附加参数后的url字符串
 */
export function buildUrl(sUrl, oParameters) {
  var result = _appendParameters(sUrl, oParameters);
  if (result.postData.length) {
    throw new Error("参数过长");
  }

  return result.url;
}

export function getIEVersion() {
  var userAgent = navigator.userAgent; //取得浏览器的userAgent字符串
  var isIE = userAgent.indexOf("compatible") > -1 && userAgent.indexOf("MSIE") > -1; //判断是否IE<11浏览器
  var isEdge = userAgent.indexOf("Edge") > -1 && !isIE; //判断是否IE的Edge浏览器
  var isIE11 = userAgent.indexOf("Trident") > -1 && userAgent.indexOf("rv:11.0") > -1;
  if (isIE) {
    var reIE = new RegExp("MSIE (\\d+\\.\\d+);");
    reIE.test(userAgent);
    var fIEVersion = parseFloat(RegExp["$1"]);
    if (fIEVersion == 7) {
      return 7;
    } else if (fIEVersion == 8) {
      return 8;
    } else if (fIEVersion == 9) {
      return 9;
    } else if (fIEVersion == 10) {
      return 10;
    } else {
      return 6; //IE版本<=7
    }
  } else if (isEdge) {
    return "edge"; //edge
  } else if (isIE11) {
    return 11; //IE11
  } else {
    return -1; //不是ie浏览器
  }
}

export function unThousands(sVal, correct) {
  if (correct === true) {
    var fTmp = parseFloat((sVal + "").replace(/,/g, ""));
    return isNaN(fTmp) ? 0 : fTmp;
  } else {
    return (sVal + "").replace(/,/g, "");
  }
}
export function precision(sVal, precision) {
  return Number(unThousands(sVal)).toFixed(precision);
}
export function precisionFunc(sVal, precision) {
  return Number(unThousands(sVal)).toFixed(precision);
}
export function thousands(num) {
  var arr = (num + "").split(".");
  var intPart = arr[0];
  var decPart = arr.length > 1 ? "." + arr[1] : "";
  return intPart.replace(/\d{1,3}(?=(\d{3})+(\.\d*)?$)/g, "$&,") + decPart;
}

/**
 * 格式化数值，根据字段配置，判断是否增加千分位、小数位、百分符号
 * val 字段的值
 * config {
 *  percentage 百分比
 *  showPercentage
 *  precision 小数位
 *  is_thousandth 千分位
 *
 *  prefixStr 前缀
 * }
 * cell 字段属性对象集合，用到属性小数位、千分位、百分位
 * prefixStr 前缀
 */
export function formatNumber(val, { prefixStr, precision, percentage, showPercentage = true, doPrecisionFunc=true, is_thousandth }) {
  var reg = /^[-+]?(([0-9]+)([.]([0-9]+))?|([.]([0-9]+))?)$/;
  var pattern = new RegExp(reg);
  if (pattern.test(val) || typeof val === "number") {//正则匹配字段是数字或者是数字的字符串 || vale是数值类型（科学计数法字符正则无法匹配）
    //1.如果字段开启了百分位，数值*100显示
    if (percentage) {
      val =  bignumber(val).times(100).toNumber();
    }

    //2.格式化小数位
    if(doPrecisionFunc)
      val = precisionFunc(val, precision);

    //3.格式化千分位
    if (is_thousandth) {
      //千分位适配
      val = val.toString();
      val = thousands(val);
    }

    //4.格式化百分符号
    if (percentage && showPercentage) {
      val += "%"; //百分比适配
    }
  }

  if (prefixStr) {
    return prefixStr + val; //添加前缀
  }

  return val;
}

function browserVersion() {
  var u = navigator.userAgent,
    app = navigator.appVersion;
  var versions = {
    trident: u.indexOf("Trident") > -1, //IE内核
    presto: u.indexOf("Presto") > -1, //opera内核
    webKit: u.indexOf("AppleWebKit") > -1, //苹果、谷歌内核
    gecko: u.indexOf("Gecko") > -1 && u.indexOf("KHTML") == -1, //火狐内核
    mobile: !!u.match(/AppleWebKit.*Mobile.*/) || !!u.match(/AppleWebKit/), //是否为移动终端
    ios: !!u.match(/\(i[^;]+;( U;)? CPU.+Mac OS X/), //ios终端
    android: u.indexOf("Android") > -1 || u.indexOf("Linux") > -1, //android终端或者uc浏览器
    iPhone: u.indexOf("iPhone") > -1 || u.indexOf("Mac") > -1, //是否为iPhone或者QQHD浏览器
    iPad: u.indexOf("iPad") > -1, //是否iPad
    webApp: u.indexOf("Safari") == -1, //是否web应该程序，没有头部与底部,
    macOs: u.indexOf("Mac") > -1, //是否mac浏览器
  };
  return versions;
}

export function isIE() {
  return browserVersion().trident;
}
export const isSafari=/^((?!chrome|android).)*safari/i.test(navigator.userAgent);


export function retryRequest({
  url,
  method = "POST",
  data,
  headers = {},
  success,
  error,
  needCancelToken,
  retryInterface, //对二次请求的数据进行处理后，再返回给当前请求再次发送
}) {
  if (!url) {
    console.log("retryRequest没有配置url，不发送请求");
    return;
  }

  return request({
    url: url,
    method: method,
    data: data,
    headers: headers,
    needCancelToken: needCancelToken,
    retryInterface: retryInterface,
  }).then(
    function (result) {
      if (result?.data?.code === 34001) {
        //需要手动确认后，再次发起

        //弹出确认框，点确认后，再次发送请求
        message.confirm({
          content: result.data.message,
          onOk: function () {
            result.config.data = JSON.parse(result.config.data); //返回的data是字符串，parse一下
            var reConfig = retryInterface?.(result.config); //对初始data做处理后，再发送给
            reConfig.data = JSON.stringify(reConfig.data); //把data转为字符串
            reConfig.success = success;
            reConfig.error = error;
            if (reConfig) {
              retryRequest(reConfig); //重新发送一次请求
            }
          },
        });
      } else {
        success?.(result);
      }
    },
    function (errorRes) {
      error?.(errorRes);
    }
  );
}

//前端根据流程标题规则计算出标题文本
export function getProcessTitle({ form_data, params, tplData }) {
  if (!form_data?.main) {
    console.log("没有传formdata.main，不计算标题");
    return;
  }
  if (!params) {
    console.log("没有传params，不计算标题");
    return;
  }
  if (!tplData) {
    console.log("没有传tplData，不计算标题");
    return;
  }
  var main_data = form_data.main;
  var blocks = [],
    date = new Date(),
    last_divider = "";
  params.name_rule.forEach(function (item) {
    if (item.type == "keyword") {
      if (item.code == "name") {
        blocks.push(tplData.ProcessInfo.ProcessModuleName + item.divider);
      } else if (item.code == "display_name") {
        blocks.push(tplData.ProcessInfo.ProcessDisplayName + item.divider);
      } else if (item.code == "y") {
        blocks.push(date.getFullYear() + item.divider);
      } else if (item.code == "m") {
        blocks.push(date.getMonth() + 1 + item.divider);
      } else if (item.code == "d") {
        blocks.push(date.getDate() + item.divider);
      } else if (item.code == "org") {
        let approveFormData = getApproveFormData({
          tplData: tplData
        });
        if (approveFormData?.initiater_org_name) {
          blocks.push(approveFormData.initiater_org_name + item.divider);
        } else {
          blocks.push("[" + item.name + "]" + item.divider);
        }
      } else {
        blocks.push("[" + item.name + "]" + item.divider);
      }
      last_divider = item.divider;
    }
    if (item.type == "field") {
      var block = main_data[item.code] ? main_data[item.code] + item.divider : "";
      var obj = null;
      var itemValue = main_data[item.code]; //标题条件实际值
      //标题条件的值是字符串，且是JSON字符串才进行
      if (typeof itemValue == "string" && (itemValue.indexOf("[") == 0 || itemValue.indexOf("{") == 0)) {
        try {
          obj = JSON.parse(main_data[item.code]);
        } catch (e) {}
        if (typeof obj == "object" && obj) {
          if (obj.length > 0) {
            var component = [];
            obj.forEach(function (item) {
              if (item.auditor_name) {
                // 选人
                component.push(item.auditor_name);
              } else if (item.org_name) {
                // 组织
                component.push(item.org_name);
              } else if (item.CountryCN) {
                // 城市
                component.push(item.CountryEN == "China" ? item.CityCN : item.CountryCN + "-" + item.CityCN);
              }
              // component.push(item.auditor_name ? item.auditor_name : (item.org_name ? item.org_name : ''));
            });
            block = component.join(",") + item.divider;
          } else {
            block = "";
          }
        }
      }
      last_divider = item.divider;
      blocks.push(block);
    }
    if (item.type == "text") {
      blocks.push(item.name + item.divider);
      last_divider = item.divider;
    }
  });
  var title = blocks.join("");
  // 去除尾部的分隔符
  if (last_divider.length > 0) {
    title = title.substr(0, title.length - last_divider.length);
  }
  return title;
}
//获取原始的字段名称： eg main.A1  zhibiao1.C1
export function getOriginField(fieldPath) {
  let originField = null;
  if (fieldPath.startsWith("form.form_data.main.")) {
    originField = fieldPath.replace("form.form_data.", "");
  } else if (fieldPath.startsWith("form.form_data.children.")) {
    originField = fieldPath.replace("form.form_data.children.", "").replace(/\[.*\]/, "");
  }
  return originField;
}

export function scrollTo({
  scrollItemClass,//需要滚动的标记
  contentClass,//需要操作滚动条的标记
  offsetY= 0//纵向偏移的像素
}){

  if(jQuery(scrollItemClass).length <= 0){//不存在滚动的元素时，不做操作
    return;
  }

  //1.获取第一个验证错误的元素，并滚动定位到相应的位置
  let $hasError = jQuery(scrollItemClass).eq(0);
  let $content = jQuery(contentClass).eq(0);

  if($content.length > 0){
    let offsetTop = $hasError.offset().top;
    let contentOffsetTop = $content.offset().top;
    let scrollTop = $content.scrollTop();
    $content.animate({
      "scrollTop": scrollTop - contentOffsetTop + offsetTop + offsetY
    }, 200)//滚动到错误元素的位置
  }

}

/**
 * 
 * @param {string} scrollItemClass 错误标记class，eg:".has-error"
 * @param {string} contentClass 需要滚动的元素class，eg:".main-content"
 * @param {Number} offsetY 纵向滚动偏移位置，eg: 10
 */
export function scrollToError({
  scrollItemClass,//需要滚动的标记
  contentClass,//需要操作滚动条的标记
  offsetY= 0//纵向偏移的像素
}){

  //1.获取第一个验证错误的元素，并滚动定位到相应的位置
  let $hasError = jQuery(scrollItemClass).eq(0);
  scrollTo({
    scrollItemClass,//错误标记
    contentClass,//需要滚动的元素
    offsetY//纵向偏移的像素
  })
  
  //2.找到错误元素下的input元素，并focus
  let $firstInput = $hasError.find("input").eq(0);
  if ($firstInput.length < 1) {//元素下没有input
    $firstInput = $hasError;//尝试给错误元素本身focus
  }
  $firstInput.focus();
}

//ie浏览器弹出框放入专属区用来处理各种IE兼容样式问题
export function getIeHack(wrapper=".main-content"){
  let ieHack={}

  if(!isIE()){
    ieHack.getPopupContainer=(config) => {
      return document.querySelector(wrapper) || config;
    }
  }
  else
  {
    ieHack.getPopupContainer=(config) => {
      return document.querySelector(".ieHackWrapper") || config
    }
    ieHack.transitionName="";
    ieHack.animation="";
  }

  return ieHack
}

/**
 * 
 * @param {string} data - 要转为对象或者对象的字符串.
 * @returns {Array} 返回值为data转换后的数组，如果无法转换为数组，就返回空数组
 */
export function parseToArray(data){
  let returnData = [];
  if(typeof data === "string"){//如果是字符串
    try{
      returnData = JSON.parse(data);//尝试转为数组
    }catch(e){
      console.log(data + "无法被JSON.parse");
    }
  }else if(Array.isArray(data)){//如果本身是数组，直接返回数组
    return returnData = data;
  }else{
    console.log("parseToArray的数据源不是字符串，也不是数组，直接返回空数组");
  }
  return returnData;
}

/**
 * @param {String} tipMessage - 校验不通过提示文本
 * @returns {Boolean} - true 有附件正在上传，false 没有附件在上传
 */
export function fileIsUploading({
  tipMessage = ""
}){
  if(window.__isFileUploading__ && Object.keys(window.__isFileUploading__).length >0){
    //调用如果给了提示文本，则提示一下
    if(tipMessage){
      message.info({
        content: tipMessage
      });
    }
    return true;//附件正在上传
  }
  return false;//附件没上传
}

//获得意见回填域的值
export function getBackFillAreaValue({
  value
}){

  //如果意见回填域数据是数组，则直接返回
  if(Array.isArray(value)){
    return value;
  }

  //意见回填域的值是一个对象，最后一个属性是一个字符串，其他的属性才是审批记录，只有属性是对象的时候，才表示是一条审批记录
  let list = [];
  if(!(value?.constructor === Object)){
    console.warn('意见回填域的值不是对象',value);
    return list;
  }
  for (let obj in value) {
    let item = value[obj];
    if (item?.constructor === Object) {
      list.push(item);
    }
  }
  return list;
}
//返回打印隐藏信息初始化配置
export function getPrintHideInfo({
  tplData
}){
  let returnData = {
    delete_group_arr: [], //分组
    delete_field_arr: [], //子表字段
    delete_col_arr: [],//主表字段
    delete_sub_title: [], //??
    show_consult_records: true,//审批流程是否显示协商信息
    show_assigned_records: true,//审批流程是否显示交办信息
    show_audit_records: tplData.show_audit_records == 1,//是否显示审批记录 如果是已审批流程需要显示审批记录筛选框 show_audit_records = 1为默认展示审批记录
    show_process_title: true,//流程标题是否显示
    detele_relation_arr: [],
    deteleRelationGroup: false,
  };
  if(tplData.show_audit_records != 1){
    //如果审批记录不显示，协商信息 和 交办信息 强制隐藏
    returnData.show_consult_records = false;
    returnData.show_assigned_records = false;
  }
  return returnData;
  
}
//判断变量是否为对象
export function isObject(obj){
  if(obj && Object.prototype.toString.call(obj) === "[object Object]"){
    return true;
  }
  return false;
}
//判断鼠标是否在dom区域内
export function isMouseInDomRect(event,domRect){
  if(domRect){
    return event.clientX >= domRect.left && event.clientX <= domRect.right &&
    event.clientY >= domRect.top && event.clientY <= domRect.bottom
  }
  return false
}
//判断变量是否为包含元素的数组
export function isNoEmptyArray(array){
  if(Array.isArray(array) && array.length > 0){
    return true;
  }
  return false;
}

/**
 * 根据format返回React日期组件需要的属性
 * @return {Array} [showTime, picker]
 * */
export function getDatePicker({
  format
}){
  if(typeof format === "string"){
    format = format.toLocaleLowerCase();//统一转换为小写进行判断
  }

  let returnData = {
    showTime: true,//显示时间选择器
    picker: "date"//选择类型
  }
  //根据format给的格式，推断前端需要展示的功能
  if (format == "yyyy-mm-dd hh:mm:ss") {//年月日时分秒
    //默认配置
  }
  if (format == "yyyy-mm-dd hh:mm") {//年月日时分
    //默认配置
  }
  if (format == "yyyy-mm-dd") {//年月日
    returnData.showTime = false;//不显示时间选择器
  }
  
  if (format == "yyyy-mm") {
    returnData.picker = "month";//只选择月，不选择时间
    returnData.showTime = false;//不显示时间选择器
  }
  return [returnData.showTime, returnData.picker];
}

/**
 * 格式化日期format为React日期组件需要的字符串
 * @param {String} format - 业务对象配置的日期format
 * @return {String} React日期组件需要的字符串
 * */
 export function parseDateformat({
  format = "YYYY-MM-DD"//配置的日期格式化，没有就默认为年月日
}){
  format = format.toLocaleUpperCase();//默认先转大写，防止配置不正确
  format = format.replace("hh", "HH").replace(":MM", ":mm").replace("SS", "ss"); //时分秒转小写
  return format;
}